Refactor/spi #554

FoniksFox · 2026-01-27T23:49:08Z

Refactor SPI to the new compile infrastructure.

It is a refactor of the base driver, it discards all the logic that was built on top of the driver and mixed with it in the previous implementation.

Uses the new DMA (will update the code a little when it's final version comes arround).

Allows any desired spi config you may need.

If you want a protocol on top of it, you have to implement it (it is out of the scope for this pr, I'm planning on doing a general protocol class that's a mixin and can use any driver, format and operations). But it is pretty easy to use with packets (will add a better explanation in the wiki later):

Define all the packets you want to transmit via spi
Take the biggest packet size as the size of your buffers
Declare tx and rx buffers
Write and read packets to these buffers, use the id to know how to interpret the data, since you will allways be sending / receiving the max amount of data
To handle the case where the slave wants to send to the master, you either have a separate pin for it, or you make the master poll all the time and make the slave know it is a poll because it uses a specific id or something, I don't know, that's on you to decide

It uses a different api for master and slave to make clear the difference in behaviour (master instantly start the operation, while slave prepares it but must wait for the master)

…uede hacer

… funcion y reorganizar un poco

…nically consteval), and a few more constexprs

…les de los modulos al start

…a estan siendo utilizadas

…ia hacer el start

…gurados

…pp, fixed irqn function, and minor changes to inscribe_dma for legibility

…a compile-time

…Alternate functions

…a cual se puede repetir). cambios en sus constructores y nuevo metodo (setDMAHandle) para poder pasar el handle desde el periferico

Copilot

Pull request overview

This PR refactors the SPI driver implementation to integrate with a new compile-time infrastructure. The refactor removes the protocol layer that was mixed with the base driver and introduces a cleaner separation of concerns using the new DMA infrastructure.

Changes:

Introduces new SPI2.hpp/cpp with compile-time configuration and separate master/slave APIs
Adds new DMA2.hpp/cpp with compile-time domain-based architecture
Comments out old SPI/DMA callback implementations in legacy code (FMAC, I2C, ADC, old SPI)
Updates ST-LIB.hpp to integrate new SPIDomain and DMA_Domain
Enables USE_FULL_ASSERT and changes library type from STATIC to OBJECT in build configuration

Reviewed changes

Copilot reviewed 20 out of 21 changed files in this pull request and generated 11 comments.

Show a summary per file

File	Description
Inc/HALAL/Models/SPI/SPI2.hpp	New SPI domain with compile-time configuration, pin validation, and separate master/slave wrapper APIs
Src/HALAL/Models/SPI/SPI2.cpp	Implementation of IRQ handlers, HAL callbacks, and prescaler calculation for new SPI
Inc/HALAL/Models/SPI/SPIConfig.hpp	New comprehensive SPI configuration types with translation to HAL constants
Inc/HALAL/Models/DMA/DMA2.hpp	New DMA domain with compile-time configuration and peripheral-specific initialization
Src/HALAL/Models/DMA/DMA2.cpp	DMA IRQ handlers for all 16 streams
Inc/ST-LIB.hpp	Integration of new SPIDomain and DMA_Domain into build context
Src/HALAL/Services/Communication/SPI/SPI.cpp	Old SPI callbacks commented out for future removal
Src/HALAL/Services/FMAC/FMAC.cpp	DMA inscribe call commented out pending migration
Src/HALAL/Services/Communication/I2C/I2C.cpp	DMA inscribe call commented out pending migration
Src/HALAL/Services/ADC/ADC.cpp	DMA-related code removed, error message updated
Inc/HALAL/Services/FMAC/FMAC.hpp	DMA stream fields removed from FMACInstance struct
Inc/HALAL/Services/Communication/SPI/SPI.hpp	DMA stream fields removed from SPI Instance
Inc/HALAL/Services/Communication/I2C/I2C.hpp	DMA stream fields removed from I2C Instance
Inc/HALAL/Services/ADC/ADC.hpp	DMA stream removed from ADC InitData
Inc/HALAL/Models/Pin.hpp	Updated PA15 alternate function mask
Inc/HALAL/HALAL.hpp	Switched from old DMA.hpp to DMA2.hpp, added SPI2.hpp
Src/HALAL/HALAL.cpp	Commented out old DMA::start() call
Src/HALAL/Models/DMA/DMA.cpp.tmp	Added Spanish comment about coexistence with new DMA
Inc/HALAL/Models/DMA/DMA.hpp	Minor formatting fix
Inc/stm32h7xx_hal_conf_template.h	Enabled USE_FULL_ASSERT for debugging
CMakeLists.txt	Changed library type from STATIC to OBJECT

Comments suppressed due to low confidence (1)

Src/HALAL/Models/DMA/DMA.cpp.tmp:10

This comment is written in Spanish and contains informal language. Comments in the codebase should be in English for consistency and international collaboration. The comment reads: "So that this code can coexist with the new dma, it has to be forced a little. I (Jorge not pm), believe that the new DMA can work for all peripherals. In case it is not like that, I will change this so it works (it will only be a moment)". This temporary comment should either be removed or properly translated and formalized.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-01-27T23:55:32Z

Inc/HALAL/Models/SPI/SPI2.hpp

+                    !compare_pin(sck_pin, PA7)) {
+                    compile_error("Invalid SCK pin for SPI6");
+                }
+                if (!compare_pin(miso_pin, PB4) &&
+                    !compare_pin(miso_pin, PG12) &&
+                    !compare_pin(miso_pin, PA6)) {
+                    compile_error("Invalid MISO pin for SPI6");
+                }
+                if (!compare_pin(mosi_pin, PB5) &&
+                    !compare_pin(mosi_pin, PG14) &&
+                    !compare_pin(mosi_pin, PA7)) {


The same pin PA7 is listed as valid for both SCK and MOSI on SPI6. This is likely an error as a single pin cannot serve two different SPI functions simultaneously. According to the STM32H7 datasheet, PA7 is typically an SPI1 MOSI pin, not an SPI6 pin. Please verify the correct pin mappings for SPI6 and update the validation accordingly.

Copilot · 2026-01-27T23:55:33Z

Inc/stm32h7xx_hal_conf_template.h

  *        HAL drivers code
  */
-/* #define USE_FULL_ASSERT    1U */
+#define USE_FULL_ASSERT    1


USE_FULL_ASSERT has been enabled (changed from commented out to defined as 1). This enables parameter assertion checks in the HAL drivers, which adds runtime overhead and code size. While this is useful for debugging, it should typically be disabled in release builds for optimal performance. Consider using conditional compilation based on build type (e.g., only enable in Debug builds) rather than enabling it unconditionally.

Copilot · 2026-01-27T23:55:33Z

Inc/HALAL/Models/SPI/SPI2.hpp

+        SPI_HandleTypeDef hspi;
+        SPI_TypeDef* instance;
+
+        volatile bool* operation_flag;


The operation_flag pointer in the Instance struct is not explicitly initialized. When Instance objects are created (as part of the instances array in Init), this pointer will have an indeterminate value. Although the callback checks for nullptr before dereferencing (line 101 in SPI2.cpp), relying on uninitialized memory to happen to be nullptr is undefined behavior. The pointer should be explicitly initialized to nullptr when the Instance is constructed to ensure predictable behavior.

Suggested change

volatile bool* operation_flag;

volatile bool* operation_flag = nullptr;

Copilot · 2026-01-27T23:55:33Z

Src/HALAL/Models/SPI/SPI2.cpp

+        prescaler *= 2; // Prescaler doubles each step (it must be a power of 2)
+
+        if (prescaler > 256) {
+            ErrorHandler("Cannot achieve desired baudrate, speed is too low");


The error message "Cannot achieve desired baudrate, speed is too low" is misleading. The condition that triggers this error is when the prescaler exceeds 256, which actually means the requested baudrate is too LOW (i.e., the source frequency cannot be divided down enough to achieve such a slow speed). The message should clarify that either the requested baudrate is too low for the given source frequency, or provide specific values to help with debugging (e.g., "Cannot achieve baudrate %u Hz with source frequency %u Hz").

Suggested change

ErrorHandler("Cannot achieve desired baudrate, speed is too low");

ErrorHandler("Cannot achieve requested baudrate: requested baudrate is too low for source frequency");

Copilot · 2026-01-27T23:55:34Z

Src/HALAL/Services/ADC/ADC.cpp

 	uint32_t buffer_length = peripheral->init_data.channels.size();
 	if (HAL_ADC_Start_DMA(peripheral->handle, (uint32_t*) peripheral->dma_data_buffer, buffer_length) != HAL_OK) {
-		ErrorHandler("DMA - %d - of ADC - %d - did not start correctly", peripheral->init_data.dma_stream, id);
+		ErrorHandler("DMA - %d - of ADC - %d - did not start correctly", id);


The error message format is incomplete. It expects a format specifier for a DMA stream parameter (the first %d), but only one argument 'id' is provided. This will cause undefined behavior when the error is triggered. The format string should either be updated to match the number of arguments, or the missing DMA stream identifier should be passed as a second argument.

Suggested change

ErrorHandler("DMA - %d - of ADC - %d - did not start correctly", id);

ErrorHandler("DMA of ADC instance %d did not start correctly", id);

Copilot · 2026-01-27T23:55:34Z

Src/HALAL/Services/Communication/SPI/SPI.cpp

+// // void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef* hspi) {}
+
+// // void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef* hspi) {}
+
+// // void HAL_SPI_ErrorCallback(SPI_HandleTypeDef* hspi) {
+// //     if ((hspi->ErrorCode & HAL_SPI_ERROR_UDR) != 0) {
+// //         SPI::spi_recover(SPI::registered_spi_by_handler[hspi], hspi);
+// //     } else {
+// //         ErrorHandler("SPI error number %u", hspi->ErrorCode);
+// //     }
+// // }



These lines contain double-commented code (// //). This appears to be an inconsistency where some code has been commented out twice. Either remove these lines entirely or use single-line comments consistently. The extra layer of commenting makes the code harder to read and suggests unclear intention about whether this code should be preserved or deleted.

Suggested change

// // void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef* hspi) {}

// // void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef* hspi) {}

// // void HAL_SPI_ErrorCallback(SPI_HandleTypeDef* hspi) {

// // if ((hspi->ErrorCode & HAL_SPI_ERROR_UDR) != 0) {

// // SPI::spi_recover(SPI::registered_spi_by_handler[hspi], hspi);

// // } else {

// // ErrorHandler("SPI error number %u", hspi->ErrorCode);

// // }

// // }

Copilot · 2026-01-27T23:55:34Z

CMakeLists.txt

@@ -218,7 +218,7 @@ list(FILTER STLIB_HIGH_CPP_NO_ETH EXCLUDE REGEX "${STLIB_HIGH_ETH_REGEX}")
 # Librería STLIB_LIBRARY
 # ============================


The library type was changed from STATIC to OBJECT without explanation. OBJECT libraries behave differently than STATIC libraries - they don't create an archive file and their object files are directly linked into targets that use them. This change can affect link-time optimization, symbol visibility, and how the library is consumed by other targets. Please document why this change was made and verify it doesn't break existing build configurations or downstream projects that depend on this library.

Suggested change

# ============================

# ============================

# NOTE / NOTA:

# This target is intentionally an OBJECT library instead of STATIC.

# Historically this library was built as STATIC, but it was changed to

# OBJECT so that its object files can be directly reused by multiple

# firmware / executable targets while still being selected via generator

# expressions (CMAKE_CROSSCOMPILING, USE_ETHERNET, etc.).

#

# Compatibility:

# - Downstream projects must link against the CMake target `${STLIB_LIBRARY}`

# (e.g. `target_link_libraries(<app> PRIVATE ${STLIB_LIBRARY})`) and must

# not rely on a `.a` or `.lib` archive file name.

# - Existing build configurations that referenced the CMake target itself

# continue to work: they still see the same sources and compile options,

# only the internal representation changed from a STATIC archive to an

# OBJECT library.

# - No public interface of the library target has been changed by this

# switch; only the way CMake materializes it at link time is different.

#

# If a downstream project requires a real archive file, it should create its

# own STATIC or SHARED target that links against `${STLIB_LIBRARY}` or wraps

# its object files with `$<TARGET_OBJECTS:${STLIB_LIBRARY}>`.

Copilot · 2026-01-27T23:55:35Z

Inc/HALAL/Models/SPI/SPI2.hpp

+            auto error_code = HAL_SPI_Transmit(&spi_instance.hspi, (uint8_t*)data.data(), data.size_bytes() / frame_size, 10);
+            return check_error_code(error_code);
+        }
+
+        /**
+         * @brief Sends a trivially copyable data type over SPI in blocking mode.
+         */
+        template <typename T>
+        bool send(const T& data) requires std::is_trivially_copyable_v<T> {
+            if (sizeof(T) % frame_size != 0) {
+                ErrorHandler("SPI data type size (%d) not aligned to frame size (%d)", sizeof(T), frame_size);
+                return false;
+            }
+            auto error_code = HAL_SPI_Transmit(&spi_instance.hspi, reinterpret_cast<const uint8_t*>(&data), sizeof(T) / frame_size, 10);
+            return check_error_code(error_code);
+        }
+
+        /**
+         * @brief Receives data over SPI in blocking mode.
+         */
+        template <typename E, size_t S>
+        bool receive(span<E, S> data) {
+            if (data.size_bytes() % frame_size != 0) {
+                ErrorHandler("SPI data size (%d) not aligned to frame size (%d)", data.size_bytes(), frame_size);
+                return false;
+            }
+            auto error_code = HAL_SPI_Receive(&spi_instance.hspi, (uint8_t*)data.data(), data.size_bytes() / frame_size, 10);
+            return check_error_code(error_code);
+        }
+
+        /**
+         * @brief Receives a trivially copyable data type over SPI in blocking mode.
+         */
+        template <typename T>
+        bool receive(T& data) requires std::is_trivially_copyable_v<T> {
+            if (sizeof(T) % frame_size != 0) {
+                ErrorHandler("SPI data type size (%d) not aligned to frame size (%d)", sizeof(T), frame_size);
+                return false;
+            }
+            auto error_code = HAL_SPI_Receive(&spi_instance.hspi, reinterpret_cast<uint8_t*>(&data), sizeof(T) / frame_size, 10);
+            return check_error_code(error_code);
+        }
+
+        /**
+         * @brief Sends and receives data over SPI in blocking mode.
+         */
+        template <typename E1, size_t S1, typename E2, size_t S2>
+        bool transceive(span<E1, S1> tx_data, span<E2, S2> rx_data) {
+            size_t size = std::min(tx_data.size_bytes(), rx_data.size_bytes());
+            if (size % frame_size != 0) {
+                ErrorHandler("SPI transaction size (%d) not aligned to frame size (%d)", size, frame_size);
+                return false;
+            }
+            auto error_code = HAL_SPI_TransmitReceive(&spi_instance.hspi, (uint8_t*)tx_data.data(), (uint8_t*)rx_data.data(), size / frame_size, 10);
+            return check_error_code(error_code);
+        }
+
+        /**
+         * @brief Sends and receives a trivially copyable data type over SPI in blocking mode.
+         */
+        template <typename E, size_t S, typename T>
+        bool transceive(span<E, S> tx_data, T& rx_data) requires std::is_trivially_copyable_v<T> {
+            size_t size = std::min(tx_data.size_bytes(), sizeof(T));
+             if (size % frame_size != 0) {
+                ErrorHandler("SPI transaction size (%d) not aligned to frame size (%d)", size, frame_size);
+                return false;
+            }
+            auto error_code = HAL_SPI_TransmitReceive(&spi_instance.hspi, (uint8_t*)tx_data.data(), reinterpret_cast<uint8_t*>(&rx_data), size / frame_size, 10);
+            return check_error_code(error_code);
+        }
+
+        /**
+         * @brief Sends and receives a trivially copyable data type over SPI in blocking mode.
+         */
+        template <typename T, typename E, size_t S>
+        bool transceive(const T& tx_data, span<E, S> rx_data) requires std::is_trivially_copyable_v<T> {
+            size_t size = std::min(sizeof(T), rx_data.size_bytes());
+             if (size % frame_size != 0) {
+                ErrorHandler("SPI transaction size (%d) not aligned to frame size (%d)", size, frame_size);
+                return false;
+            }
+            auto error_code = HAL_SPI_TransmitReceive(&spi_instance.hspi, reinterpret_cast<const uint8_t*>(&tx_data), (uint8_t*)rx_data.data(), size / frame_size, 10);
+            return check_error_code(error_code);
+        }
+
+        /**
+         * @brief Sends and receives a trivially copyable data type over SPI in blocking mode.
+         */
+        template <typename T1, typename T2>
+        bool transceive(const T1& tx_data, T2& rx_data) requires (std::is_trivially_copyable_v<T1> && std::is_trivially_copyable_v<T2>) {
+            size_t size = std::min(sizeof(T1), sizeof(T2));
+             if (size % frame_size != 0) {
+                ErrorHandler("SPI transaction size (%d) not aligned to frame size (%d)", size, frame_size);
+                return false;
+            }
+            auto error_code = HAL_SPI_TransmitReceive(&spi_instance.hspi, reinterpret_cast<const uint8_t*>(&tx_data), reinterpret_cast<uint8_t*>(&rx_data), size / frame_size, 10);


All blocking SPI operations use a hardcoded timeout value of 10 milliseconds. This magic number should be either: (1) defined as a named constant to make it clear what it represents and allow for easy modification, or (2) made configurable per-device to accommodate different use cases. Some SPI operations may require longer timeouts depending on the slave device and data size, while others may need shorter timeouts.

Copilot · 2026-01-27T23:55:35Z

Inc/HALAL/Models/SPI/SPI2.hpp

+                if (!compare_pin(sck_pin, PB3) &&
+                    !compare_pin(sck_pin, PG11) &&
+                    !compare_pin(sck_pin, PA5)) {
+                    compile_error("Invalid SCK pin for SPI1");
+                }
+                if (!compare_pin(miso_pin, PB4) &&
+                    !compare_pin(miso_pin, PG9) &&
+                    !compare_pin(miso_pin, PA6)) {
+                    compile_error("Invalid MISO pin for SPI1");
+                }
+                if (!compare_pin(mosi_pin, PB5) &&
+                    !compare_pin(mosi_pin, PD7) &&
+                    !compare_pin(mosi_pin, PA7)) {
+                    compile_error("Invalid MOSI pin for SPI1");
+                }
+                break;
+
+            case SPIPeripheral::spi2:
+                if (!compare_pin(sck_pin, PD3) &&
+                    !compare_pin(sck_pin, PA12) &&
+                    !compare_pin(sck_pin, PA9) &&
+                    !compare_pin(sck_pin, PB13) &&
+                    !compare_pin(sck_pin, PB10)) {
+                    compile_error("Invalid SCK pin for SPI2");
+                }
+                if (!compare_pin(miso_pin, PC2) &&
+                    !compare_pin(miso_pin, PB14)) {
+                    compile_error("Invalid MISO pin for SPI2");
+                }
+                if (!compare_pin(mosi_pin, PC3) &&
+                    !compare_pin(mosi_pin, PC1) &&
+                    !compare_pin(mosi_pin, PB15)) {
+                    compile_error("Invalid MOSI pin for SPI2");
+                }
+                break;
+
+            case SPIPeripheral::spi3:
+                if (!compare_pin(sck_pin, PB3) &&
+                    !compare_pin(sck_pin, PC10)) {
+                    compile_error("Invalid SCK pin for SPI3");
+                }    
+                if (!compare_pin(miso_pin, PB4) &&
+                    !compare_pin(miso_pin, PC11)) {
+                    compile_error("Invalid MISO pin for SPI3");
+                }
+                if (!compare_pin(mosi_pin, PB5) &&
+                    !compare_pin(mosi_pin, PD6) &&
+                    !compare_pin(mosi_pin, PC12) &&
+                    !compare_pin(mosi_pin, PB2)) {
+                    compile_error("Invalid MOSI pin for SPI3");
+                }
+                break;
+
+            case SPIPeripheral::spi4:
+                if (!compare_pin(sck_pin, PE2) &&
+                    !compare_pin(sck_pin, PE12)) {
+                    compile_error("Invalid SCK pin for SPI4");
+                }
+                if (!compare_pin(miso_pin, PE5) &&
+                    !compare_pin(miso_pin, PE13)) {
+                    compile_error("Invalid MISO pin for SPI4");
+                }
+                if (!compare_pin(mosi_pin, PE6) &&
+                    !compare_pin(mosi_pin, PE14)) {
+                    compile_error("Invalid MOSI pin for SPI4");
+                }
+                break;
+
+            case SPIPeripheral::spi5:
+                if (!compare_pin(sck_pin, PF7)) {
+                    compile_error("Invalid SCK pin for SPI5");
+                }
+                if (!compare_pin(miso_pin, PF8)) {
+                    compile_error("Invalid MISO pin for SPI5");
+                }
+                if (!compare_pin(mosi_pin, PF9) &&
+                    !compare_pin(mosi_pin, PF11)) {
+                    compile_error("Invalid MOSI pin for SPI5");
+                }
+                break;
+
+            case SPIPeripheral::spi6:
+                if (!compare_pin(sck_pin, PB3) &&
+                    !compare_pin(sck_pin, PG13) &&
+                    !compare_pin(sck_pin, PC10) && 
+                    !compare_pin(sck_pin, PA7)) {
+                    compile_error("Invalid SCK pin for SPI6");
+                }
+                if (!compare_pin(miso_pin, PB4) &&
+                    !compare_pin(miso_pin, PG12) &&
+                    !compare_pin(miso_pin, PA6)) {
+                    compile_error("Invalid MISO pin for SPI6");
+                }
+                if (!compare_pin(mosi_pin, PB5) &&
+                    !compare_pin(mosi_pin, PG14) &&
+                    !compare_pin(mosi_pin, PA7)) {
+                    compile_error("Invalid MOSI pin for SPI6");
+                }


Pin PC10 is listed as valid for both SPI3 (line 304) and SPI6 (line 350) SCK pins. Additionally, PB3 is listed for SPI1, SPI3, and SPI6 SCK, and PB4 is listed for SPI1, SPI3, and SPI6 MISO. While it's possible for pins to support multiple peripherals through alternate functions, this should be verified against the STM32H7 datasheet. If these are indeed valid, users need to be careful not to configure multiple SPI peripherals with overlapping pins simultaneously.

Copilot · 2026-01-27T23:55:35Z

Src/HALAL/Models/SPI/SPI2.cpp

+        prescaler *= 2; // Prescaler doubles each step (it must be a power of 2)
+
+        if (prescaler > 256) {
+            ErrorHandler("Cannot achieve desired baudrate, speed is too low");


After calling ErrorHandler when prescaler exceeds 256, the function continues execution and attempts to call get_prescaler_flag with an invalid prescaler value (>256). The function should either return a default prescaler value or use a more severe error handling mechanism that doesn't return. Consider adding 'return SPI_BAUDRATEPRESCALER_256;' after the ErrorHandler call to provide a fallback behavior.

Suggested change

ErrorHandler("Cannot achieve desired baudrate, speed is too low");

ErrorHandler("Cannot achieve desired baudrate, speed is too low");

return SPI_BAUDRATEPRESCALER_256;

Cantonplas and others added 30 commits November 17, 2025 20:01

It compiles the old version with constexpr

09de7c7

Draft of the new dma class

8962c95

Minor change on where is the instance declared on dma.hpp

1d158c0

limpieza de funciones, enums y structs

ea78eb3

feat: distintos inscribe definidos, no creo que sea lo mejor que se p…

b8df87e

…uede hacer

feat: mejor enfoque, pero no se si el correcto

85db060

feat: comprueba el numero de perifericos, cambios de nombre a algunas…

52ae1a5

… funcion y reorganizar un poco

feat: struct constructor, better is... logic, refactor inscribe (tech…

3dd6ae4

…nically consteval), and a few more constexprs

algunas cosillas para que compile. falta conseguir pasarle las variab…

8ca78ee

…les de los modulos al start

feat: agregar static a las variables constexpr

3c44a60

me lo quiero pasar al PC solamente, luego hago bien el commit

d2005f2

feat: agregar funciones que comprueban si el stream y la instancias y…

9d2a930

…a estan siendo utilizadas

fuck constexpr, todo en runtime. feat: inscribe funciona, solo quedar…

38fd08b

…ia hacer el start

repartir entre archivos las funciones y hacer el start

4d0e6be

feat: start completado, mejor estructura, todos los perifericos confi…

cca62c8

…gurados

hacer funciones inline para que pueda compilar

5212ce9

adc inscribe_dma now working, moved dma implementations from cpp to h…

9655dea

…pp, fixed irqn function, and minor changes to inscribe_dma for legibility

Initial structure

e2af8c5

no need to have an id for instance

3eec305

erased no longer needed code

fa3498b

Juntar estructura propuesta de compiletime con la clase DMA

c338bf8

cambio de nombre al antiguo dma y empiezo con la nueva infraestructur…

0440eb4

…a compile-time

añadir funciones de configuracion del handle DMA

98a34fb

Added DigitalInput and DigitalOutput Services, and added support for …

c1966cf

…Alternate functions

todo lo facil hecho, queda lo dificil (handle y global_handle)

b245442

entry, build e instances_ ahora se rigen por stream y no instancia (l…

ba25865

…a cual se puede repetir). cambios en sus constructores y nuevo metodo (setDMAHandle) para poder pasar el handle desde el periferico

se me habia olvidado desreferenciar

968eee6

modificar STLIB.hpp para meter el contexto de la DMA

0826a02

throws comentados, una dma menos

4c8a7f3

It compiles the old version with constexpr

fb86f46

FoniksFox added 27 commits January 14, 2026 18:09

fix(SPI): Typo in ErrorHandler function name

b0e1516

fix(SPI): Move spi_instances declaration

d6595a3

fix(SPI): General syntax errror fixes

7f0e3d8

feat(SPI): Add SPI domain to ST-LIB

c090b4b

fix(SPI): Remove forgotten line

288e5c0

fix(SPI): General fixes to make it compile

4d6f8b4

fix(SPI): Forgot to set up max baudrate

3af6613

Merge remote-tracking branch 'origin/feat/DMA-updated' into refactor/SPI

b86ca78

Merge branch 'development' into feat/DMA-updated

101d022

feat(DMA): udpate inscribe method to return indices

1bd4fc2

Merge branch 'feat/DMA-updated' into refactor/SPI

2f20354

feat(SPI): Add DMA linking

eb72bf6

feat(SPI): Implement configuration API + some cleanup

980fa9c

fix(SPI): Update SPI in ST-LIB.hpp

ba15465

feat(SPI): Make inscribe return size_t

a6402af

fix(SPI): Fix compile_error

5cce7e4

Merge remote-tracking branch 'origin/development' into refactor/SPI

4ce57b8

fix(SPI): Fix inscribe

72f165b

fix(SPI): Fix things

8404700

Merge remote-tracking branch 'origin/development' into refactor/SPI

2a92b34

fix(SPI): Pin A15 AF were incorrect

6538aff

Merge remote-tracking branch 'origin/development' into refactor/SPI

94ae350

fix(SPI): Fix instances array

a6cc1e3

Merge remote-tracking branch 'origin/development' into refactor/SPI

ff3cf48

feat(SPI): Add templated functions to acccept anything

6d49eb3

fix(SPI): Alignments and correct frame calculations

770f323

feat(SPI): Add slave software nss interface

1731518

Copilot AI review requested due to automatic review settings January 27, 2026 23:49

Copilot started reviewing on behalf of FoniksFox January 27, 2026 23:49 View session

Copilot AI reviewed Jan 27, 2026

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Refactor/spi #554

Refactor/spi #554

Uh oh!

FoniksFox commented Jan 27, 2026

Uh oh!

Copilot AI left a comment

Uh oh!

Copilot AI Jan 27, 2026

Uh oh!

Copilot AI Jan 27, 2026

Uh oh!

Copilot AI Jan 27, 2026

Uh oh!

Copilot AI Jan 27, 2026

Uh oh!

Copilot AI Jan 27, 2026

Uh oh!

Copilot AI Jan 27, 2026

Uh oh!

Copilot AI Jan 27, 2026

Uh oh!

Copilot AI Jan 27, 2026

Uh oh!

Copilot AI Jan 27, 2026

Uh oh!

Copilot AI Jan 27, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

5 participants

	volatile bool* operation_flag;
	volatile bool* operation_flag = nullptr;

	ErrorHandler("Cannot achieve desired baudrate, speed is too low");
	ErrorHandler("Cannot achieve requested baudrate: requested baudrate is too low for source frequency");

	ErrorHandler("DMA - %d - of ADC - %d - did not start correctly", id);
	ErrorHandler("DMA of ADC instance %d did not start correctly", id);

		@@ -218,7 +218,7 @@ list(FILTER STLIB_HIGH_CPP_NO_ETH EXCLUDE REGEX "${STLIB_HIGH_ETH_REGEX}")
		# Librería STLIB_LIBRARY
		# ============================

-# ============================
+# ============================
+# NOTE / NOTA:
+#   This target is intentionally an OBJECT library instead of STATIC.
+#   Historically this library was built as STATIC, but it was changed to
+#   OBJECT so that its object files can be directly reused by multiple
+#   firmware / executable targets while still being selected via generator
+#   expressions (CMAKE_CROSSCOMPILING, USE_ETHERNET, etc.).
+#
+#   Compatibility:
+#   - Downstream projects must link against the CMake target `${STLIB_LIBRARY}`
+#     (e.g. `target_link_libraries(<app> PRIVATE ${STLIB_LIBRARY})`) and must
+#     not rely on a `.a` or `.lib` archive file name.
+#   - Existing build configurations that referenced the CMake target itself
+#     continue to work: they still see the same sources and compile options,
+#     only the internal representation changed from a STATIC archive to an
+#     OBJECT library.
+#   - No public interface of the library target has been changed by this
+#     switch; only the way CMake materializes it at link time is different.
+#
+#   If a downstream project requires a real archive file, it should create its
+#   own STATIC or SHARED target that links against `${STLIB_LIBRARY}` or wraps
+#   its object files with `$<TARGET_OBJECTS:${STLIB_LIBRARY}>`.

	ErrorHandler("Cannot achieve desired baudrate, speed is too low");
	ErrorHandler("Cannot achieve desired baudrate, speed is too low");
	return SPI_BAUDRATEPRESCALER_256;

Refactor/spi #554

Are you sure you want to change the base?

Refactor/spi #554

Uh oh!

Conversation

FoniksFox commented Jan 27, 2026

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Copilot AI Jan 27, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 27, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 27, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 27, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 27, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 27, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 27, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 27, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 27, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 27, 2026

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

5 participants